#include <Arduino.h>
#include "ai_farm_analyzer.h"

// 灌溉控制器类
class IrrigationControl {
private:
  // 引脚定义
  int pumpRelayPin;        // 水泵继电器引脚
  int fanRelayPin;         // 风扇继电器引脚
  int lightRelayPin;       // 灯光继电器引脚
  
  // 状态变量
  bool pumpState;          // 水泵状态
  bool fanState;           // 风扇状态
  bool lightState;         // 灯光状态
  
  // 定时器变量
  unsigned long pumpStartTime;  // 水泵启动时间
  unsigned long fanStartTime;   // 风扇启动时间
  unsigned long lightStartTime; // 灯光启动时间
  
  // 运行时间限制
  unsigned long maxPumpRuntime; // 水泵最大运行时间
  unsigned long maxFanRuntime;  // 风扇最大运行时间
  
  // 保护参数
  bool safetyEnabled;      // 安全功能是否启用
  float overcurrentThreshold; // 过流阈值
  
  // 内部方法
  void controlPump(bool state, float wateringTime = 0);
  void controlFan(bool state);
  void controlLighting(bool state);
  bool checkSafetyConditions();
  bool monitorCurrent(int pin);
  void logControlEvent(String event);

public:
  // 构造函数
  IrrigationControl(int pumpPin, int fanPin, int lightPin);
  
  // 初始化函数
  void init();
  
  // 执行控制指令
  void executeControl(const FarmRecommendation& recommendation);
  
  // 手动控制方法
  void manualPumpControl(bool state, float duration = 0);
  void manualFanControl(bool state);
  void manualLightControl(bool state);
  
  // 状态查询方法
  bool isPumpRunning();
  bool isFanRunning();
  bool isLightRunning();
  
  // 安全功能控制
  void enableSafety(bool enable);
  void setMaxPumpRuntime(unsigned long seconds);
  void setMaxFanRuntime(unsigned long seconds);
  
  // 检查系统状态
  bool isSystemHealthy();
};

// 构造函数
IrrigationControl::IrrigationControl(int pumpPin, int fanPin, int lightPin) {
  pumpRelayPin = pumpPin;
  fanRelayPin = fanPin;
  lightRelayPin = lightPin;
  
  pumpState = false;
  fanState = false;
  lightState = false;
  
  pumpStartTime = 0;
  fanStartTime = 0;
  lightStartTime = 0;
  
  maxPumpRuntime = 300; // 默认最大水泵运行时间 (5分钟)
  maxFanRuntime = 600;  // 默认最大风扇运行时间 (10分钟)
  
  safetyEnabled = true;
  overcurrentThreshold = 10.0f; // 默认过流阈值 (10A)
}

// 初始化函数
void IrrigationControl::init() {
  // 配置继电器引脚为输出
  pinMode(pumpRelayPin, OUTPUT);
  pinMode(fanRelayPin, OUTPUT);
  pinMode(lightRelayPin, OUTPUT);
  
  // 初始状态为关闭
  digitalWrite(pumpRelayPin, LOW);
  digitalWrite(fanRelayPin, LOW);
  digitalWrite(lightRelayPin, LOW);
  
  // 记录初始化事件
  logControlEvent("灌溉控制系统初始化完成");
}

// 执行控制指令
void IrrigationControl::executeControl(const FarmRecommendation& recommendation) {
  // 检查安全条件
  if (!checkSafetyConditions()) {
    logControlEvent("安全条件不满足，暂停所有控制操作");
    return;
  }
  
  // 根据优先级调整控制策略
  if (recommendation.priorityLevel >= 4) {
    // 高优先级：立即执行所有建议操作
    if (recommendation.irrigate) {
      controlPump(true, recommendation.recommendedWateringTime);
    }
    
    if (recommendation.adjustVentilation) {
      controlFan(true);
    } else if (!recommendation.irrigate) {
      // 如果不需要灌溉且不需要通风，则关闭风扇
      controlFan(false);
    }
    
    if (recommendation.adjustLighting) {
      // 在实际应用中，这里应该根据光照传感器读数和时间来决定是否开启灯光
      // 简化版：如果是白天且光照不足，则开启灯光；如果是晚上，则关闭灯光
      // 这里需要结合系统的时间和光照传感器数据
      // 由于没有这些数据，我们暂时根据建议状态控制
      controlLighting(true);
    } else {
      controlLighting(false);
    }
  } else if (recommendation.priorityLevel >= 2) {
    // 中优先级：执行重要操作，次要操作延迟或根据条件执行
    if (recommendation.irrigate) {
      controlPump(true, recommendation.recommendedWateringTime);
    }
    
    if (recommendation.adjustVentilation) {
      controlFan(true);
    }
    
    // 灯光控制可以延迟或根据实际情况决定
  } else {
    // 低优先级：执行基本操作，其他操作根据资源情况决定
    if (recommendation.irrigate) {
      controlPump(true, recommendation.recommendedWateringTime);
    }
    
    // 其他控制操作可以根据实际资源情况决定
  }
  
  // 检查运行时间限制，自动关闭设备
  checkRuntimeLimits();
}

// 控制水泵
void IrrigationControl::controlPump(bool state, float wateringTime) {
  if (state && !pumpState) {
    // 开启水泵
    digitalWrite(pumpRelayPin, HIGH);
    pumpState = true;
    pumpStartTime = millis();
    
    String event = "水泵已开启";
    if (wateringTime > 0) {
      event += ", 计划运行时间: " + String(wateringTime) + "分钟";
    }
    logControlEvent(event);
  } else if (!state && pumpState) {
    // 关闭水泵
    digitalWrite(pumpRelayPin, LOW);
    pumpState = false;
    logControlEvent("水泵已关闭");
  }
  
  // 如果指定了浇水时间，设置定时器
  if (state && wateringTime > 0) {
    // 在实际应用中，应该设置一个定时器在指定时间后关闭水泵
    // 这里我们简化处理，在主循环中检查运行时间
  }
}

// 控制风扇
void IrrigationControl::controlFan(bool state) {
  if (state && !fanState) {
    // 开启风扇
    digitalWrite(fanRelayPin, HIGH);
    fanState = true;
    fanStartTime = millis();
    logControlEvent("风扇已开启");
  } else if (!state && fanState) {
    // 关闭风扇
    digitalWrite(fanRelayPin, LOW);
    fanState = false;
    logControlEvent("风扇已关闭");
  }
}

// 控制灯光
void IrrigationControl::controlLighting(bool state) {
  if (state && !lightState) {
    // 开启灯光
    digitalWrite(lightRelayPin, HIGH);
    lightState = true;
    lightStartTime = millis();
    logControlEvent("灯光已开启");
  } else if (!state && lightState) {
    // 关闭灯光
    digitalWrite(lightRelayPin, LOW);
    lightState = false;
    logControlEvent("灯光已关闭");
  }
}

// 检查安全条件
bool IrrigationControl::checkSafetyConditions() {
  if (!safetyEnabled) {
    return true;
  }
  
  // 检查过流保护
  if (pumpState && monitorCurrent(pumpRelayPin)) {
    logControlEvent("水泵过流，已自动关闭");
    controlPump(false);
    return false;
  }
  
  if (fanState && monitorCurrent(fanRelayPin)) {
    logControlEvent("风扇过流，已自动关闭");
    controlFan(false);
    return false;
  }
  
  // 检查其他安全条件
  // 例如：检查雨水传感器，防止在下雨时灌溉
  // 检查系统电压，防止在电压异常时运行
  
  return true;
}

// 监控电流
bool IrrigationControl::monitorCurrent(int pin) {
  // 简化的电流监控函数
  // 在实际应用中，应该使用电流传感器来监测实际电流
  
  // 这里返回false表示没有过流
  return false;
}

// 记录控制事件
void IrrigationControl::logControlEvent(String event) {
  // 在实际应用中，应该将事件记录到SD卡或通过网络发送到服务器
  // 这里我们简化处理，只输出到串口
  Serial.print("[灌溉控制] ");
  Serial.println(event);
}

// 手动控制水泵
void IrrigationControl::manualPumpControl(bool state, float duration) {
  if (safetyEnabled && !checkSafetyConditions()) {
    logControlEvent("安全条件不满足，无法手动控制水泵");
    return;
  }
  
  controlPump(state, duration);
}

// 手动控制风扇
void IrrigationControl::manualFanControl(bool state) {
  if (safetyEnabled && !checkSafetyConditions()) {
    logControlEvent("安全条件不满足，无法手动控制风扇");
    return;
  }
  
  controlFan(state);
}

// 手动控制灯光
void IrrigationControl::manualLightControl(bool state) {
  controlLighting(state);
}

// 检查水泵是否运行
bool IrrigationControl::isPumpRunning() {
  return pumpState;
}

// 检查风扇是否运行
bool IrrigationControl::isFanRunning() {
  return fanState;
}

// 检查灯光是否运行
bool IrrigationControl::isLightRunning() {
  return lightState;
}

// 启用/禁用安全功能
void IrrigationControl::enableSafety(bool enable) {
  safetyEnabled = enable;
  logControlEvent("安全功能" + (enable ? "已启用" : "已禁用"));
}

// 设置水泵最大运行时间
void IrrigationControl::setMaxPumpRuntime(unsigned long seconds) {
  maxPumpRuntime = seconds;
  logControlEvent("水泵最大运行时间已设置为: " + String(seconds) + "秒");
}

// 设置风扇最大运行时间
void IrrigationControl::setMaxFanRuntime(unsigned long seconds) {
  maxFanRuntime = seconds;
  logControlEvent("风扇最大运行时间已设置为: " + String(seconds) + "秒");
}

// 检查系统是否健康
bool IrrigationControl::isSystemHealthy() {
  // 检查继电器状态
  bool relayOk = true;
  
  // 检查水泵继电器
  digitalWrite(pumpRelayPin, HIGH);
  delay(50);
  // 在实际应用中，应该使用反馈电路来检查继电器是否真正动作
  digitalWrite(pumpRelayPin, LOW);
  
  // 检查风扇继电器
  digitalWrite(fanRelayPin, HIGH);
  delay(50);
  digitalWrite(fanRelayPin, LOW);
  
  // 检查灯光继电器
  digitalWrite(lightRelayPin, HIGH);
  delay(50);
  digitalWrite(lightRelayPin, LOW);
  
  // 检查安全条件
  bool safetyOk = checkSafetyConditions();
  
  return relayOk && safetyOk;
}

// 检查运行时间限制
void IrrigationControl::checkRuntimeLimits() {
  unsigned long currentTime = millis();
  
  // 检查水泵运行时间
  if (pumpState && (currentTime - pumpStartTime) > (maxPumpRuntime * 1000)) {
    logControlEvent("水泵运行时间超过限制，已自动关闭");
    controlPump(false);
  }
  
  // 检查风扇运行时间
  if (fanState && (currentTime - fanStartTime) > (maxFanRuntime * 1000)) {
    logControlEvent("风扇运行时间超过限制，已自动关闭");
    controlFan(false);
  }
  
  // 灯光没有时间限制，因为它通常由光照条件控制
}